{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configuration for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt install python-opengl\n",
    "    !apt install ffmpeg\n",
    "    !apt install xvfb\n",
    "    !pip install pyvirtualdisplay\n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(600, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 03. DDPG\n",
    "\n",
    "[T. P. Lillicrap et al., \"Continuous control with deep reinforcement learning.\" arXiv preprint arXiv:1509.02971, 2015.](https://arxiv.org/pdf/1509.02971.pdf)\n",
    "\n",
    "Deep Q Network(DQN)([Mnih et al., 2013;2015](https://storage.googleapis.com/deepmind-media/dqn/DQNNaturePaper.pdf)) algorithm is combined advances in deep learning with reinforcement learning. However, while DQN solves problems with high-dimentional observation spaces, it can only handle discrete and low-dimentional action spaces because of using greedy policy. For learning in high-dimentional and continous action spaces, the authors combine the actor-critic approach with insights from the recent success of DQN. Deep DPG(DDPG) is based on the deterministic policy gradient(DPG) algorithm ([Silver et al., 2014](http://proceedings.mlr.press/v32/silver14.pdf)). \n",
    "\n",
    "### Deterministic policy gradient\n",
    "The DPG algorithm maintains a parameterized actor function $\\mu(s|\\theta^{\\mu})$ which specifies the current policy by deterministically mapping states to a specific action. The critic $Q(s, a)$ is learned using the Bellman equation as in Q-learning. The actor is updated by following the applying the chain rule to the expected return from the start distribution $J$ with respect to the actor parameters\n",
    "\n",
    "$$\n",
    "\\begin{align*}\n",
    "\\nabla_{\\theta^{\\mu}}J &\\approx E_{s_t\\sim\\rho^\\beta} [\\nabla_{\\theta^{\\mu}} Q(s,a|\\theta^Q)|_{s=s_t, a=\\mu(s_t|\\theta^\\mu)}] \\\\\n",
    "&= E_{s_t\\sim\\rho^\\beta} [\\nabla_{a} Q(s,a|\\theta^Q)|_{s=s_t, a=\\mu(s_t)} \\nabla_{\\theta^{\\mu}} \\mu(s|\\theta^\\mu)|_{s=s_t}]\n",
    "\\end{align*}\n",
    "$$\n",
    "\n",
    "### Replay buffer\n",
    "One challenge when using neural networks for reinforcement learning is that most optimization algorithms assume that **the samples are independently and identically distributed**. When the samples are generated from exploring sequentially in an environment this assumption no longer holds. The authors used a **replay buffer** to address these issues. Transitions were sampled from the environment according to the exploration policy and the tuple $(s_t, a_t, r_t, s_{t+1})$ was stored in the replay buffer. At each timestep the actor and critic are updated by sampling a minibatch uniformly from the buffer. It allows to benefit from learning across a set of **uncorrelated** transitions.\n",
    "\n",
    "### Soft update target network\n",
    "Since the network $(Q(s,a|\\theta^Q)$ being updated is also used in calculating the target value, the Q update is prone to divergence. To avoid this, the authors use **the target network** like DQN, but modified for actor-critic and using **soft target updates**. Target netwokrs is created by copying the actor and critic networks, $Q'(s,a|\\theta^{Q'})$ and $\\mu'(s|\\theta^{\\mu`})$ respectively, that are used for calculating the target values. The weights of these target networks are then updated by having them slowly track the learned networks:\n",
    "\n",
    "$$\n",
    "\\theta' \\leftarrow \\tau \\theta + (1 - \\tau)\\theta' \\ \\ \\ {with} \\ \\tau \\ll 1.\n",
    "$$\n",
    "\n",
    "It greatly improves the stability of learning.\n",
    "\n",
    "### Exploration for continuous action space\n",
    "An advantage of offpolicies algorithms such as DDPG is that we can treat the problem of exploration independently from the learning algorithm. The authors construct an exploration policy $\\mu'$ by adding noise sampled from a noise process $\\mathcal{N}$ to the actor policy\n",
    "\n",
    "$$\n",
    "\\mu'(s_t) = \\mu(s_t|\\theta^{\\mu}_t) + \\mathcal{N}\n",
    "$$\n",
    "\n",
    "$\\mathcal{N}$ can be chosen to suit the environment. The authors used **Ornstein-Uhlenbeck process** to generate temporally correlated exploration."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "import random\n",
    "from typing import Dict, List, Tuple\n",
    "\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "\n",
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "if torch.backends.cudnn.enabled:\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "\n",
    "seed = 777\n",
    "torch.manual_seed(seed)\n",
    "np.random.seed(seed)\n",
    "random.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer\n",
    "Typically, people implement replay buffers with one of the following three data structures:\n",
    "\n",
    "- collections.deque\n",
    "- list\n",
    "- numpy.ndarray\n",
    "\n",
    "**deque** is very easy to handle once you initialize its maximum length (e.g. deque(maxlen=buffer_size)). However, the indexing operation of deque gets terribly slow as it grows up because it is [internally doubly linked list](https://wiki.python.org/moin/TimeComplexity#collections.deque). On the other hands, **list** is an array, so it is relatively faster than deque when you sample batches at every step. Its amortized cost of Get item is [O(1)](https://wiki.python.org/moin/TimeComplexity#list).\n",
    "\n",
    "Last but not least, let's see **numpy.ndarray**. numpy.ndarray is even faster than list due to the fact that it is [a homogeneous array of fixed-size items](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html#numpy.ndarray), so you can get the benefits of [locality of reference](https://en.wikipedia.org/wiki/Locality_of_reference), . Whereas list is an array of pointers to objects, even when all of them are of the same type.\n",
    "\n",
    "Here, we are going to implement a replay buffer using numpy.ndarray.\n",
    "\n",
    "Reference: \n",
    "- [OpenAI spinning-up](https://github.com/openai/spinningup/blob/master/spinup/algos/sac/sac.py#L10)\n",
    "- [rainbow-is-all-you-need](https://render.githubusercontent.com/view/ipynb?commit=032d11277cf2436853478a69ca5a4aba03202598&enc_url=68747470733a2f2f7261772e67697468756275736572636f6e74656e742e636f6d2f437572742d5061726b2f7261696e626f772d69732d616c6c2d796f752d6e6565642f303332643131323737636632343336383533343738613639636135613461626130333230323539382f30312e64716e2e6970796e62&nwo=Curt-Park%2Frainbow-is-all-you-need&path=01.dqn.ipynb&repository_id=191133946&repository_type=Repository#Replay-buffer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(self, obs_dim: int, size: int, batch_size: int = 32):\n",
    "        \"\"\"Initializate.\"\"\"\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "\n",
    "    def store(\n",
    "        self,\n",
    "        obs: np.ndarray,\n",
    "        act: np.ndarray, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool,\n",
    "    ):\n",
    "        \"\"\"Store the transition in buffer.\"\"\"\n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        \"\"\"Randomly sample a batch of experiences from memory.\"\"\"\n",
    "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
    "        return dict(obs=self.obs_buf[idxs],\n",
    "                    next_obs=self.next_obs_buf[idxs],\n",
    "                    acts=self.acts_buf[idxs],\n",
    "                    rews=self.rews_buf[idxs],\n",
    "                    done=self.done_buf[idxs])\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## OU Noise\n",
    "**Ornstein-Uhlenbeck** process generates temporally correlated exploration, and it effectively copes with physical control problems of inertia.\n",
    "\n",
    "$$\n",
    "dx_t = \\theta(\\mu - x_t) dt + \\sigma dW_t\n",
    "$$\n",
    "\n",
    "Reference: \n",
    "- [Udacity github](https://github.com/udacity/deep-reinforcement-learning/blob/master/ddpg-pendulum/ddpg_agent.py)\n",
    "- [Wiki](https://en.wikipedia.org/wiki/Ornstein%E2%80%93Uhlenbeck_process)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class OUNoise:\n",
    "    \"\"\"Ornstein-Uhlenbeck process.\n",
    "    Taken from Udacity deep-reinforcement-learning github repository:\n",
    "    https://github.com/udacity/deep-reinforcement-learning/blob/master/\n",
    "    ddpg-pendulum/ddpg_agent.py\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        size: int, \n",
    "        mu: float = 0.0, \n",
    "        theta: float = 0.15, \n",
    "        sigma: float = 0.2,\n",
    "    ):\n",
    "        \"\"\"Initialize parameters and noise process.\"\"\"\n",
    "        self.state = np.float64(0.0)\n",
    "        self.mu = mu * np.ones(size)\n",
    "        self.theta = theta\n",
    "        self.sigma = sigma\n",
    "        self.reset()\n",
    "\n",
    "    def reset(self):\n",
    "        \"\"\"Reset the internal state (= noise) to mean (mu).\"\"\"\n",
    "        self.state = copy.copy(self.mu)\n",
    "\n",
    "    def sample(self) -> np.ndarray:\n",
    "        \"\"\"Update internal state and return it as a noise sample.\"\"\"\n",
    "        x = self.state\n",
    "        dx = self.theta * (self.mu - x) + self.sigma * np.array(\n",
    "            [random.random() for _ in range(len(x))]\n",
    "        )\n",
    "        self.state = x + dx\n",
    "        return self.state"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "We are going to use two separated networks for actor and critic. The actor network has three fully connected layers and three non-linearity functions, **ReLU** for hidden layers and **tanh** for the output layer. On the other hand, the critic network has three fully connected layers, but it used two activation functions for hidden layers **ReLU**. Plus, its input sizes of critic network are sum of state sizes and action sizes. One thing to note is that we initialize the final layer's weights and biases so that they are **uniformly distributed.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Actor(nn.Module):\n",
    "    def __init__(\n",
    "        self, \n",
    "        in_dim: int, \n",
    "        out_dim: int,\n",
    "        init_w: float = 3e-3,\n",
    "    ):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        super(Actor, self).__init__()\n",
    "        \n",
    "        self.hidden1 = nn.Linear(in_dim, 128)\n",
    "        self.hidden2 = nn.Linear(128, 128)\n",
    "        self.out = nn.Linear(128, out_dim)\n",
    "        \n",
    "        self.out.weight.data.uniform_(-init_w, init_w)\n",
    "        self.out.bias.data.uniform_(-init_w, init_w)\n",
    "\n",
    "    def forward(self, state: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        x = F.relu(self.hidden1(state))\n",
    "        x = F.relu(self.hidden2(x))\n",
    "        action = self.out(x).tanh()\n",
    "        \n",
    "        return action\n",
    "    \n",
    "    \n",
    "class Critic(nn.Module):\n",
    "    def __init__(\n",
    "        self, \n",
    "        in_dim: int, \n",
    "        init_w: float = 3e-3,\n",
    "    ):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        super(Critic, self).__init__()\n",
    "        \n",
    "        self.hidden1 = nn.Linear(in_dim, 128)\n",
    "        self.hidden2 = nn.Linear(128, 128)\n",
    "        self.out = nn.Linear(128, 1)\n",
    "        \n",
    "        self.out.weight.data.uniform_(-init_w, init_w)\n",
    "        self.out.bias.data.uniform_(-init_w, init_w)\n",
    "\n",
    "    def forward(\n",
    "        self, state: torch.Tensor, action: torch.Tensor\n",
    "    ) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        x = torch.cat((state, action), dim=-1)\n",
    "        x = F.relu(self.hidden1(x))\n",
    "        x = F.relu(self.hidden2(x))\n",
    "        value = self.out(x)\n",
    "        \n",
    "        return value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DDPG Agent\n",
    "Here is a summary of DDPGAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "|---               |---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|\\_target_soft_update| soft update from the local model to the target model.|\n",
    "|\\_plot              | plot the training progresses.                        |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DDPGAgent:\n",
    "    \"\"\"DDPGAgent interacting with environment.\n",
    "    \n",
    "    Attribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        actor (nn.Module): target actor model to select actions\n",
    "        actor_target (nn.Module): actor model to predict next actions\n",
    "        actor_optimizer (Optimizer): optimizer for training actor\n",
    "        critic (nn.Module): critic model to predict state values\n",
    "        critic_target (nn.Module): target critic model to predict state values\n",
    "        critic_optimizer (Optimizer): optimizer for training critic\n",
    "        memory (ReplayBuffer): replay memory to store transitions\n",
    "        batch_size (int): batch size for sampling\n",
    "        gamma (float): discount factor\n",
    "        tau (float): parameter for soft target update\n",
    "        initial_random_steps (int): initial random action steps\n",
    "        noise (OUNoise): noise generator for exploration\n",
    "        device (torch.device): cpu / gpu\n",
    "        transition (list): temporory storage for the recent transition\n",
    "        total_step (int): total step numbers\n",
    "        is_test (bool): flag to show the current mode (train / test)\n",
    "    \"\"\"\n",
    "    def __init__(\n",
    "        self,\n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        ou_noise_theta: float,\n",
    "        ou_noise_sigma: float,\n",
    "        gamma: float = 0.99,\n",
    "        tau: float = 5e-3,\n",
    "        initial_random_steps: int = 1e4,\n",
    "    ):\n",
    "        \"\"\"Initialize.\"\"\"\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.shape[0]\n",
    "\n",
    "        self.env = env\n",
    "        self.memory = ReplayBuffer(obs_dim, memory_size, batch_size)\n",
    "        self.batch_size = batch_size\n",
    "        self.gamma = gamma\n",
    "        self.tau = tau\n",
    "        self.initial_random_steps = initial_random_steps\n",
    "                \n",
    "        # noise\n",
    "        self.noise = OUNoise(\n",
    "            action_dim,\n",
    "            theta=ou_noise_theta,\n",
    "            sigma=ou_noise_sigma,\n",
    "        )\n",
    "\n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\n",
    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        )\n",
    "        print(self.device)\n",
    "\n",
    "        # networks\n",
    "        self.actor = Actor(obs_dim, action_dim).to(self.device)\n",
    "        self.actor_target = Actor(obs_dim, action_dim).to(self.device)\n",
    "        self.actor_target.load_state_dict(self.actor.state_dict())\n",
    "        \n",
    "        self.critic = Critic(obs_dim + action_dim).to(self.device)\n",
    "        self.critic_target = Critic(obs_dim + action_dim).to(self.device)\n",
    "        self.critic_target.load_state_dict(self.critic.state_dict())\n",
    "\n",
    "        # optimizer\n",
    "        self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=3e-4)\n",
    "        self.critic_optimizer = optim.Adam(self.critic.parameters(), lr=1e-3)\n",
    "        \n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # total steps count\n",
    "        self.total_step = 0\n",
    "\n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "    \n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # if initial random action should be conducted\n",
    "        if self.total_step < self.initial_random_steps and not self.is_test:\n",
    "            selected_action = self.env.action_space.sample()\n",
    "        else:\n",
    "            selected_action = self.actor(\n",
    "                torch.FloatTensor(state).to(self.device)\n",
    "            ).detach().cpu().numpy()\n",
    "        \n",
    "        # add noise for exploration during training\n",
    "        if not self.is_test:\n",
    "            noise = self.noise.sample()\n",
    "            selected_action = np.clip(selected_action + noise, -1.0, 1.0)\n",
    "        \n",
    "        self.transition = [state, selected_action]\n",
    "        \n",
    "        return selected_action\n",
    "    \n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, done, _ = self.env.step(action)\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            self.memory.store(*self.transition)\n",
    "    \n",
    "        return next_state, reward, done\n",
    "    \n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        \n",
    "        samples = self.memory.sample_batch()\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.FloatTensor(samples[\"acts\"].reshape(-1, 1)).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "        \n",
    "        masks = 1 - done\n",
    "        next_action = self.actor_target(next_state)\n",
    "        next_value = self.critic_target(next_state, next_action)\n",
    "        curr_return = reward + self.gamma * next_value * masks\n",
    "        \n",
    "        # train critic\n",
    "        values = self.critic(state, action)\n",
    "        critic_loss = F.mse_loss(values, curr_return)\n",
    "        \n",
    "        self.critic_optimizer.zero_grad()\n",
    "        critic_loss.backward()\n",
    "        self.critic_optimizer.step()\n",
    "                \n",
    "        # train actor\n",
    "        actor_loss = -self.critic(state, self.actor(state)).mean()\n",
    "        \n",
    "        self.actor_optimizer.zero_grad()\n",
    "        actor_loss.backward()\n",
    "        self.actor_optimizer.step()\n",
    "        \n",
    "        # target update\n",
    "        self._target_soft_update()\n",
    "        \n",
    "        return actor_loss.data, critic_loss.data\n",
    "    \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        actor_losses = []\n",
    "        critic_losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "        \n",
    "        for self.total_step in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "            # if episode ends\n",
    "            if done:         \n",
    "                state = env.reset()\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if (\n",
    "                len(self.memory) >= self.batch_size \n",
    "                and self.total_step > self.initial_random_steps\n",
    "            ):\n",
    "                actor_loss, critic_loss = self.update_model()\n",
    "                actor_losses.append(actor_loss)\n",
    "                critic_losses.append(critic_loss)\n",
    "            \n",
    "            # plotting\n",
    "            if self.total_step % plotting_interval == 0:\n",
    "                self._plot(\n",
    "                    self.total_step, \n",
    "                    scores, \n",
    "                    actor_losses, \n",
    "                    critic_losses,\n",
    "                )\n",
    "                \n",
    "        self.env.close()\n",
    "        \n",
    "    def test(self):\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        frames = []\n",
    "        while not done:\n",
    "            frames.append(self.env.render(mode=\"rgb_array\"))\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "        \n",
    "        return frames\n",
    "    \n",
    "    def _target_soft_update(self):\n",
    "        \"\"\"Soft-update: target = tau*local + (1-tau)*target.\"\"\"\n",
    "        tau = self.tau\n",
    "        \n",
    "        for t_param, l_param in zip(\n",
    "            self.actor_target.parameters(), self.actor.parameters()\n",
    "        ):\n",
    "            t_param.data.copy_(tau * l_param.data + (1.0 - tau) * t_param.data)\n",
    "            \n",
    "        for t_param, l_param in zip(\n",
    "            self.critic_target.parameters(), self.critic.parameters()\n",
    "        ):\n",
    "            t_param.data.copy_(tau * l_param.data + (1.0 - tau) * t_param.data)\n",
    "    \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        actor_losses: List[float], \n",
    "        critic_losses: List[float], \n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        def subplot(loc: int, title: str, values: List[float]):\n",
    "            plt.subplot(loc)\n",
    "            plt.title(title)\n",
    "            plt.plot(values)\n",
    "\n",
    "        subplot_params = [\n",
    "            (131, f\"frame {frame_idx}. score: {np.mean(scores[-10:])}\", scores),\n",
    "            (132, \"actor_loss\", actor_losses),\n",
    "            (133, \"critic_loss\", critic_losses),\n",
    "        ]\n",
    "        \n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(30, 5))\n",
    "        for loc, title, values in subplot_params:\n",
    "            subplot(loc, title, values)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "*ActionNormalizer* is an action wrapper class to normalize the action values ranged in (-1. 1). Thanks to this class, we can make the agent simply select action values within the zero centered range (-1, 1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ActionNormalizer(gym.ActionWrapper):\n",
    "    \"\"\"Rescale and relocate the actions.\"\"\"\n",
    "\n",
    "    def action(self, action: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Change the range (-1, 1) to (low, high).\"\"\"\n",
    "        low = self.action_space.low\n",
    "        high = self.action_space.high\n",
    "\n",
    "        scale_factor = (high - low) / 2\n",
    "        reloc_factor = high - scale_factor\n",
    "\n",
    "        action = action * scale_factor + reloc_factor\n",
    "        action = np.clip(action, low, high)\n",
    "\n",
    "        return action\n",
    "\n",
    "    def reverse_action(self, action: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Change the range (low, high) to (-1, 1).\"\"\"\n",
    "        low = self.action_space.low\n",
    "        high = self.action_space.high\n",
    "\n",
    "        scale_factor = (high - low) / 2\n",
    "        reloc_factor = high - scale_factor\n",
    "\n",
    "        action = (action - reloc_factor) / scale_factor\n",
    "        action = np.clip(action, -1.0, 1.0)\n",
    "\n",
    "        return action"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see [the code](https://github.com/openai/gym/blob/master/gym/envs/classic_control/pendulum.py) and [configurations](https://github.com/openai/gym/blob/cedecb35e3428985fd4efad738befeb75b9077f1/gym/envs/__init__.py#L81) of Pendulum-v0 from OpenAI's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# environment\n",
    "env_id = \"Pendulum-v0\"\n",
    "env = gym.make(env_id)\n",
    "env = ActionNormalizer(env)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[777]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def seed_torch(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.backends.cudnn.enabled:\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "\n",
    "seed = 777\n",
    "random.seed(seed)\n",
    "np.random.seed(seed)\n",
    "seed_torch(seed)\n",
    "env.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 50000\n",
    "memory_size = 100000\n",
    "batch_size = 128\n",
    "ou_noise_theta = 1.0\n",
    "ou_noise_sigma = 0.1\n",
    "initial_random_steps = 10000\n",
    "\n",
    "agent = DDPGAgent(\n",
    "    env, \n",
    "    memory_size, \n",
    "    batch_size,\n",
    "    ou_noise_theta,\n",
    "    ou_noise_sigma,\n",
    "    initial_random_steps=initial_random_steps\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score:  -241.1583482566556\n"
     ]
    }
   ],
   "source": [
    "# test\n",
    "if IN_COLAB:\n",
    "    agent.env = gym.wrappers.Monitor(agent.env, \"videos\", force=True)\n",
    "frames = agent.test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Define the Animation class */\n",
       "  function Animation(frames, img_id, slider_id, interval, loop_select_id){\n",
       "    this.img_id = img_id;\n",
       "    this.slider_id = slider_id;\n",
       "    this.loop_select_id = loop_select_id;\n",
       "    this.interval = interval;\n",
       "    this.current_frame = 0;\n",
       "    this.direction = 0;\n",
       "    this.timer = null;\n",
       "    this.frames = new Array(frames.length);\n",
       "\n",
       "    for (var i=0; i<frames.length; i++)\n",
       "    {\n",
       "     this.frames[i] = new Image();\n",
       "     this.frames[i].src = frames[i];\n",
       "    }\n",
       "    document.getElementById(this.slider_id).max = this.frames.length - 1;\n",
       "    this.set_frame(this.current_frame);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.get_loop_state = function(){\n",
       "    var button_group = document[this.loop_select_id].state;\n",
       "    for (var i = 0; i < button_group.length; i++) {\n",
       "        var button = button_group[i];\n",
       "        if (button.checked) {\n",
       "            return button.value;\n",
       "        }\n",
       "    }\n",
       "    return undefined;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.set_frame = function(frame){\n",
       "    this.current_frame = frame;\n",
       "    document.getElementById(this.img_id).src = this.frames[this.current_frame].src;\n",
       "    document.getElementById(this.slider_id).value = this.current_frame;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.next_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.min(this.frames.length - 1, this.current_frame + 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.previous_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.max(0, this.current_frame - 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.first_frame = function()\n",
       "  {\n",
       "    this.set_frame(0);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.last_frame = function()\n",
       "  {\n",
       "    this.set_frame(this.frames.length - 1);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.slower = function()\n",
       "  {\n",
       "    this.interval /= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.faster = function()\n",
       "  {\n",
       "    this.interval *= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_forward = function()\n",
       "  {\n",
       "    this.current_frame += 1;\n",
       "    if(this.current_frame < this.frames.length){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.first_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.last_frame();\n",
       "        this.reverse_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.last_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_reverse = function()\n",
       "  {\n",
       "    this.current_frame -= 1;\n",
       "    if(this.current_frame >= 0){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.last_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.first_frame();\n",
       "        this.play_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.first_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.pause_animation = function()\n",
       "  {\n",
       "    this.direction = 0;\n",
       "    if (this.timer){\n",
       "      clearInterval(this.timer);\n",
       "      this.timer = null;\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.play_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = 1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_forward();}, this.interval);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.reverse_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = -1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_reverse();}, this.interval);\n",
       "  }\n",
       "</script>\n",
       "\n",
       "<div class=\"animation\" align=\"center\">\n",
       "    <img id=\"_anim_imgASAWWLQFALTHTDDJ\">\n",
       "    <br>\n",
       "    <input id=\"_anim_sliderASAWWLQFALTHTDDJ\" type=\"range\" style=\"width:350px\" name=\"points\" min=\"0\" max=\"1\" step=\"1\" value=\"0\" onchange=\"animASAWWLQFALTHTDDJ.set_frame(parseInt(this.value));\"></input>\n",
       "    <br>\n",
       "    <button onclick=\"animASAWWLQFALTHTDDJ.slower()\">&#8211;</button>\n",
       "    <button onclick=\"animASAWWLQFALTHTDDJ.first_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animASAWWLQFALTHTDDJ.previous_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animASAWWLQFALTHTDDJ.reverse_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animASAWWLQFALTHTDDJ.pause_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animASAWWLQFALTHTDDJ.play_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animASAWWLQFALTHTDDJ.next_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animASAWWLQFALTHTDDJ.last_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animASAWWLQFALTHTDDJ.faster()\">+</button>\n",
       "  <form action=\"#n\" name=\"_anim_loop_selectASAWWLQFALTHTDDJ\" class=\"anim_control\">\n",
       "    <input type=\"radio\" name=\"state\" value=\"once\" > Once </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"loop\" checked> Loop </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"reflect\" > Reflect </input>\n",
       "  </form>\n",
       "</div>\n",
       "\n",
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Instantiate the Animation class. */\n",
       "  /* The IDs given should match those used in the template above. */\n",
       "  (function() {\n",
       "    var img_id = \"_anim_imgASAWWLQFALTHTDDJ\";\n",
       "    var slider_id = \"_anim_sliderASAWWLQFALTHTDDJ\";\n",
       "    var loop_select_id = \"_anim_loop_selectASAWWLQFALTHTDDJ\";\n",
       "    var frames = new Array(0);\n",
       "    \n",
       "  frames[0] = \"\"\n",
       "  frames[1] = \"\"\n",
       "  frames[2] = \"\"\n",
       "  frames[3] = \"\"\n",
       "  frames[4] = \"\"\n",
       "  frames[5] = \"\"\n",
       "  frames[6] = \"\"\n",
       "  frames[7] = \"\"\n",
       "  frames[8] = \"\"\n",
       "  frames[9] = \"\"\n",
       "  frames[10] = \"\"\n",
       "  frames[11] = \"\"\n",
       "  frames[12] = \"\"\n",
       "  frames[13] = \"\"\n",
       "  frames[14] = \"\"\n",
       "  frames[15] = \"\"\n",
       "  frames[16] = \"\"\n",
       "  frames[17] = \"\"\n",
       "  frames[18] = \"\"\n",
       "  frames[19] = \"\"\n",
       "  frames[20] = \"\"\n",
       "  frames[21] = \"\"\n",
       "  frames[22] = \"\"\n",
       "  frames[23] = \"\"\n",
       "  frames[24] = \"\"\n",
       "  frames[25] = \"\"\n",
       "  frames[26] = \"\"\n",
       "  frames[27] = \"\"\n",
       "  frames[28] = \"\"\n",
       "  frames[29] = \"\"\n",
       "  frames[30] = \"\"\n",
       "  frames[31] = \"\"\n",
       "  frames[32] = \"\"\n",
       "  frames[33] = \"\"\n",
       "  frames[34] = \"\"\n",
       "  frames[35] = \"\"\n",
       "  frames[36] = \"\"\n",
       "  frames[37] = \"\"\n",
       "  frames[38] = \"\"\n",
       "  frames[39] = \"\"\n",
       "  frames[40] = \"\"\n",
       "  frames[41] = \"\"\n",
       "  frames[42] = \"\"\n",
       "  frames[43] = \"\"\n",
       "  frames[44] = \"\"\n",
       "  frames[45] = \"\"\n",
       "  frames[46] = \"\"\n",
       "  frames[47] = \"\"\n",
       "  frames[48] = \"\"\n",
       "  frames[49] = \"\"\n",
       "  frames[50] = \"\"\n",
       "  frames[51] = \"\"\n",
       "  frames[52] = \"\"\n",
       "  frames[53] = \"\"\n",
       "  frames[54] = \"\"\n",
       "  frames[55] = \"\"\n",
       "  frames[56] = \"\"\n",
       "  frames[57] = \"\"\n",
       "  frames[58] = \"\"\n",
       "  frames[59] = \"\"\n",
       "  frames[60] = \"\"\n",
       "  frames[61] = \"\"\n",
       "  frames[62] = \"\"\n",
       "  frames[63] = \"\"\n",
       "  frames[64] = \"\"\n",
       "  frames[65] = \"\"\n",
       "  frames[66] = \"\"\n",
       "  frames[67] = \"\"\n",
       "  frames[68] = \"\"\n",
       "  frames[69] = \"\"\n",
       "  frames[70] = \"\"\n",
       "  frames[71] = \"\"\n",
       "  frames[72] = \"\"\n",
       "  frames[73] = \"\"\n",
       "  frames[74] = \"\"\n",
       "  frames[75] = \"\"\n",
       "  frames[76] = \"\"\n",
       "  frames[77] = \"\"\n",
       "  frames[78] = \"\"\n",
       "  frames[79] = \"\"\n",
       "  frames[80] = \"\"\n",
       "  frames[81] = \"\"\n",
       "  frames[82] = \"\"\n",
       "  frames[83] = \"\"\n",
       "  frames[84] = \"\"\n",
       "  frames[85] = \"\"\n",
       "  frames[86] = \"\"\n",
       "  frames[87] = \"\"\n",
       "  frames[88] = \"\"\n",
       "  frames[89] = \"\"\n",
       "  frames[90] = \"\"\n",
       "  frames[91] = \"\"\n",
       "  frames[92] = \"\"\n",
       "  frames[93] = \"\"\n",
       "  frames[94] = \"\"\n",
       "  frames[95] = \"\"\n",
       "  frames[96] = \"\"\n",
       "  frames[97] = \"\"\n",
       "  frames[98] = \"\"\n",
       "  frames[99] = \"\"\n",
       "  frames[100] = \"\"\n",
       "  frames[101] = \"\"\n",
       "  frames[102] = \"\"\n",
       "  frames[103] = \"\"\n",
       "  frames[104] = \"\"\n",
       "  frames[105] = \"\"\n",
       "  frames[106] = \"\"\n",
       "  frames[107] = \"\"\n",
       "  frames[108] = \"\"\n",
       "  frames[109] = \"\"\n",
       "  frames[110] = \"\"\n",
       "  frames[111] = \"\"\n",
       "  frames[112] = \"\"\n",
       "  frames[113] = \"\"\n",
       "  frames[114] = \"\"\n",
       "  frames[115] = \"\"\n",
       "  frames[116] = \"\"\n",
       "  frames[117] = \"\"\n",
       "  frames[118] = \"\"\n",
       "  frames[119] = \"\"\n",
       "  frames[120] = \"\"\n",
       "  frames[121] = \"\"\n",
       "  frames[122] = \"\"\n",
       "  frames[123] = \"\"\n",
       "  frames[124] = \"\"\n",
       "  frames[125] = \"\"\n",
       "  frames[126] = \"\"\n",
       "  frames[127] = \"\"\n",
       "  frames[128] = \"\"\n",
       "  frames[129] = \"\"\n",
       "  frames[130] = \"\"\n",
       "  frames[131] = \"\"\n",
       "  frames[132] = \"\"\n",
       "  frames[133] = \"\"\n",
       "  frames[134] = \"\"\n",
       "  frames[135] = \"\"\n",
       "  frames[136] = \"\"\n",
       "  frames[137] = \"\"\n",
       "  frames[138] = \"\"\n",
       "  frames[139] = \"\"\n",
       "  frames[140] = \"\"\n",
       "  frames[141] = \"\"\n",
       "  frames[142] = \"\"\n",
       "  frames[143] = \"\"\n",
       "  frames[144] = \"\"\n",
       "  frames[145] = \"\"\n",
       "  frames[146] = \"\"\n",
       "  frames[147] = \"\"\n",
       "  frames[148] = \"\"\n",
       "  frames[149] = \"\"\n",
       "  frames[150] = \"\"\n",
       "  frames[151] = \"\"\n",
       "  frames[152] = \"\"\n",
       "  frames[153] = \"\"\n",
       "  frames[154] = \"\"\n",
       "  frames[155] = \"\"\n",
       "  frames[156] = \"\"\n",
       "  frames[157] = \"\"\n",
       "  frames[158] = \"\"\n",
       "  frames[159] = \"\"\n",
       "  frames[160] = \"\"\n",
       "  frames[161] = \"\"\n",
       "  frames[162] = \"\"\n",
       "  frames[163] = \"\"\n",
       "  frames[164] = \"\"\n",
       "  frames[165] = \"\"\n",
       "  frames[166] = \"\"\n",
       "  frames[167] = \"\"\n",
       "  frames[168] = \"\"\n",
       "  frames[169] = \"\"\n",
       "  frames[170] = \"\"\n",
       "  frames[171] = \"\"\n",
       "  frames[172] = \"\"\n",
       "  frames[173] = \"\"\n",
       "  frames[174] = \"\"\n",
       "  frames[175] = \"\"\n",
       "  frames[176] = \"\"\n",
       "  frames[177] = \"\"\n",
       "  frames[178] = \"\"\n",
       "  frames[179] = \"\"\n",
       "  frames[180] = \"\"\n",
       "  frames[181] = \"\"\n",
       "  frames[182] = \"\"\n",
       "  frames[183] = \"\"\n",
       "  frames[184] = \"\"\n",
       "  frames[185] = \"\"\n",
       "  frames[186] = \"\"\n",
       "  frames[187] = \"\"\n",
       "  frames[188] = \"\"\n",
       "  frames[189] = \"\"\n",
       "  frames[190] = \"\"\n",
       "  frames[191] = \"\"\n",
       "  frames[192] = \"\"\n",
       "  frames[193] = \"\"\n",
       "  frames[194] = \"\"\n",
       "  frames[195] = \"\"\n",
       "  frames[196] = \"\"\n",
       "  frames[197] = \"\"\n",
       "  frames[198] = \"\"\n",
       "  frames[199] = \"\"\n",
       "\n",
       "\n",
       "    /* set a timeout to make sure all the above elements are created before\n",
       "       the object is initialized. */\n",
       "    setTimeout(function() {\n",
       "        animASAWWLQFALTHTDDJ = new Animation(frames, img_id, slider_id, 50, loop_select_id);\n",
       "    }, 0);\n",
       "  })()\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if IN_COLAB:  # for colab\n",
    "    import base64\n",
    "    import glob\n",
    "    import io\n",
    "    import os\n",
    "\n",
    "    from IPython.display import HTML, display\n",
    "\n",
    "    def ipython_show_video(path: str) -> None:\n",
    "        \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
    "        if not os.path.isfile(path):\n",
    "            raise NameError(\"Cannot access: {}\".format(path))\n",
    "\n",
    "        video = io.open(path, \"r+b\").read()\n",
    "        encoded = base64.b64encode(video)\n",
    "\n",
    "        display(HTML(\n",
    "            data=\"\"\"\n",
    "            <video alt=\"test\" controls>\n",
    "            <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
    "            </video>\n",
    "            \"\"\".format(encoded.decode(\"ascii\"))\n",
    "        ))\n",
    "\n",
    "    list_of_files = glob.glob(\"videos/*.mp4\")\n",
    "    latest_file = max(list_of_files, key=os.path.getctime)\n",
    "    print(latest_file)\n",
    "    ipython_show_video(latest_file)\n",
    "\n",
    "else:  # for jupyter\n",
    "    from matplotlib import animation\n",
    "    from JSAnimation.IPython_display import display_animation\n",
    "    from IPython.display import display\n",
    "\n",
    "\n",
    "    def display_frames_as_gif(frames):\n",
    "        \"\"\"Displays a list of frames as a gif, with controls.\"\"\"\n",
    "        patch = plt.imshow(frames[0])\n",
    "        plt.axis('off')\n",
    "\n",
    "        def animate(i):\n",
    "            patch.set_data(frames[i])\n",
    "\n",
    "        anim = animation.FuncAnimation(\n",
    "            plt.gcf(), animate, frames = len(frames), interval=50\n",
    "        )\n",
    "        display(display_animation(anim, default_mode='loop'))\n",
    "\n",
    "\n",
    "    # display \n",
    "    display_frames_as_gif(frames)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "pgayn",
   "language": "python",
   "name": "pgayn"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
